This PR implements a comprehensive Foreign Function Interface (FFI) and syscall support system that enables writing TSPP standard libraries in TSPP itself rather than requiring C++ implementations. This addresses the need for more flexible and maintainable standard library development.

Key Features

External Function Declarations

Added support for declaring and calling external functions using the extern keyword:

// Basic external function declaration
extern function my_function(param1: int, param2: string): int;

// External function with custom library name
extern function print_message(msg: string): void "libc_print";

Comprehensive Syscall Interface

Implemented a complete syscall wrapper system that provides direct access to operating system functions:

// Generic syscalls for any system call number
extern function tspp_syscall0(number: int): int;
extern function tspp_syscall3(number: int, arg1: int, arg2: int, arg3: int): int;

// Common syscall wrappers for frequently used operations
extern function tspp_sys_open(pathname: string, flags: int, mode: int): int;
extern function tspp_sys_write(fd: int, buf: string, count: int): int;
extern function tspp_sys_close(fd: int): int;

Self-Hosted Standard Libraries

Standard library modules can now be written entirely in TSPP using syscalls:

// File I/O module written in TSPP
function createFile(path: string): int {
    const O_WRONLY = 1;
    const O_CREAT = 64;
    return tspp_sys_open(path, O_WRONLY | O_CREAT, 0644);
}

function console_log(message: string): void {
    tspp_sys_write(1, message, 50);
    tspp_sys_write(1, "\n", 1);
}

Node.js-Style Console Utilities

Implemented a comprehensive console library with familiar Node.js-style syntax:

// Node.js-compatible console functions
console_log("Hello World!");
console_info("Application started");
console_warn("This is a warning");
console_error("Something went wrong");
console_time("operation");
// ... some work ...
console_timeEnd("operation");

Implementation Details

Language Extensions

• Added EXTERN token type and lexer support
• Extended parser with buildExternFunction() method for parsing external declarations
• Enhanced AST with isExternal and externalName fields in FunctionDecl

Code Generation

• Modified LLVM code generator to declare external functions without bodies
• Updated call expression handling to resolve external functions
• Added external function mapping for runtime linking

Syscall Infrastructure

• Created syscall.h/cpp module with platform-specific implementations
• Integrated syscall module into the build system
• Provided both generic and specific syscall wrappers

Console Library Features

• Styled Output: ANSI color codes for different log levels (info=cyan, warn=yellow, error=red)
• Visual Indicators: Icons for each log type (ℹ info, ⚠ warn, ✖ error, 🐛 debug, 📍 trace)
• Performance Timing: console_time() and console_timeEnd() utilities
• Development Tools: Assertions, grouping, table display, and screen clearing
• Zero Dependencies: Implemented entirely using direct syscalls

Example Files Corrections

• Grammar Fixes: Updated examples/hello_world.tspp and examples/functions.tspp to use proper TSPP grammar (function instead of func, int instead of number)
• Node.js Compatibility: Replaced non-standard println() with Node.js-style console_log() functions
• Syscall Integration: Added external function declarations to example files to demonstrate the FFI system

Benefits

1. Performance: Direct syscall access eliminates C++ wrapper overhead
2. Maintainability: Standard library code in TSPP is more readable and modifiable
3. Flexibility: Easy to extend system capabilities without compiler modifications
4. Self-Hosting: Enables building a complete standard library ecosystem in TSPP
5. Familiar APIs: Node.js-style console functions for developer productivity
6. Correct Examples: Example files now demonstrate proper TSPP grammar and Node.js-style APIs

Examples and Documentation

The PR includes comprehensive examples demonstrating:

• File I/O operations using syscalls
• Memory management with mmap/munmap
• Console I/O implementation with Node.js-style APIs
• Process utilities
• Complete working console library with styled output
• Corrected example files showing proper TSPP grammar and Node.js-style console usage

Complete documentation is provided in docs/FFI_SYSCALLS.md and examples/stdlib/README.md covering syntax, usage patterns, and implementation details.

Testing

Added integration tests for external function parsing and syscall functionality. The implementation successfully compiles and generates correct LLVM IR for external function calls. All example files now compile correctly with proper TSPP grammar.

This implementation provides the foundation for a self-hosted standard library ecosystem, enabling developers to write system-level code in TSPP itself with familiar Node.js-style APIs rather than requiring C++ implementations.

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.